home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BEERSRC.ZIP / XMODEC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-27  |  11.8 KB  |  429 lines
  1. /*-------------------------------------------------------*/
  2. /*                                                       */
  3. /*       C part of the VGA undocumented 320x240          */
  4. /*       graphics pack.                                  */
  5. /*                                                       */
  6. /*          [c] copyright by Alpha-Helix 1992.           */
  7. /*              written by Dany Schoch                   */
  8. /*                                                       */
  9. /*-------------------------------------------------------*/
  10.  
  11.  
  12.  
  13. #include <io.h>
  14. #include <sys\stat.h>
  15. #include <fcntl.h>
  16. #include <alloc.h>
  17. #include <dos.h>
  18. #include <mem.h>
  19.  
  20. #include "xmode.def"
  21.  
  22.  
  23. #define selectplane(x)        outport(SC_INDEX, (x << 8) + MAP_MASK)
  24. #define selectmask(x)        outport(GC_INDEX, (x << 8) + BIT_MASK)
  25.  
  26.  
  27. // Graphic window.
  28.  
  29. int   windowx0, windowy0;           // Upper left corber.
  30. int   windowx1, windowy1;               // Lower right corner.
  31.  
  32.  
  33. static char far *scrptr;
  34.  
  35.  
  36. /*------------------------------------------------------
  37. Function: defstarfield
  38.  
  39. Description: Defines a STARFIELD, but doesn't animate it
  40.          yet. WARNING: (x, y) coordinates in
  41.          '*star' will get destroyed if used.
  42. ------------------------------------------------------*/
  43.  
  44. void defstarfield(int n, struct starstrc *star)
  45. {
  46.    int   i;
  47.  
  48.    _sfield.n = n;
  49.    _sfield.star = star;
  50.    _sfield.go = FALSE;
  51.    for (i = 0; i < n; i++) {
  52.       star[i].x = star[i].y*BYTESPERLINE + star[i].x/4;
  53.       star[i].speed *= BYTESPERLINE;
  54.    }
  55.    _sfield.active = TRUE;
  56.  
  57. }
  58.  
  59.  
  60. void killstarfield(void)
  61. {
  62.  
  63.    _sfield.active = FALSE;
  64.  
  65. }
  66.  
  67.  
  68.  
  69. /*------------------------------------------------------
  70. Function: defsprite
  71.  
  72. Description:
  73.    Prepares a sprite to be used by the low level sprite routines.
  74.    On successful completion 'defsprite' returns a sprite HANDLE.
  75.    Don't lose this number or you will lose access to the sprite
  76.    (and memory will be lost!).
  77.    If no free entry could be found, 'defsprite' returns -1.
  78.  
  79.    args: *sprite -> pointer to sprite structure
  80.      align   -> 4: only x coords as a multiple of 4 are supported.
  81.             2: even x coords are supported.
  82. ------------------------------------------------------*/
  83.  
  84. int defsprite(void *sprite, unsigned flags)
  85. {
  86.  
  87.    int            i, a, n, x, y, p;
  88.    struct sprstrc *spr;
  89.    struct lowspr  *s;
  90.    int            align;
  91.    int            xs, ys, maxn, size;
  92.    int            plane;
  93.    char far       *data;
  94.    char far       *mask;
  95.  
  96.    spr = (struct sprstrc *)sprite;
  97.    align = 4 - (flags & SPR_ALIGN);
  98.    for (i = 0; i < MAXSPRITES; i++) {
  99.       if (!_sprite[i].active) {        // Look for a free sprite slot.
  100.      s = &_sprite[i];
  101.      xs = spr->xs; ys = spr->ys; maxn = spr->maxn;
  102.      s->xs = xs; s->ys = ys;
  103.      s->maxn = maxn*2;
  104.      if (flags & SPR_DOUBLE) s->nadd = 1; else s->nadd = 2;
  105.      xs = (xs+3+align) & 0xfffc;
  106.      size = (xs/4) * ys;
  107.      s->xsalign = xs;
  108.      s->picsize = size;
  109.      s->seqsize = size*maxn*(align/2);
  110.      s->fullsize = size*maxn*(align/2 + 1);
  111.  
  112. // Copy graphic data to offscreen memory now and create mask image.
  113.  
  114.      selectmask(0xff);
  115.      if ((mask = s->mask = (char far *)malloc(s->fullsize)) == NULL)
  116.         return -1;
  117.      s->data = scrptr;
  118.  
  119.      for (a = 0; a <= align; a+=2) {
  120.         data = spr->data;
  121.         for (n = 0; n < maxn; n++) {
  122.            for (y = 0; y < ys; y++) {
  123.           for (x = 0; x < xs; x+=4) {
  124.              plane = 0;
  125.              for (p = 0; p < 4; p++) {
  126.             selectplane(1 << p);
  127.             if ((x+p < spr->xs+a) && (x+p >= a)) {
  128.                if ((*scrptr = data[x+p-a]) != 0) {
  129.                   plane |= (1 << p);
  130.                }
  131.             }
  132.              }
  133.              if (FP_OFF(++scrptr) == 0) {  // Out of offscreen memory ?
  134.             free(mask);
  135.             return -1;
  136.              }
  137.              *mask = plane;
  138.              mask++;
  139.           }
  140.           data += spr->xs;
  141.            }
  142.         }
  143.      }
  144.  
  145.      s->active = TRUE;
  146.      return i;
  147.       }
  148.    }
  149.  
  150.    return -1;
  151.  
  152. }
  153.  
  154.  
  155. void killsprite(int sprite)
  156. {
  157.    char far *scr1;
  158.    char far *scr2;
  159.    int  i;
  160.  
  161.  
  162.    if (_sprite[sprite].active) {
  163.       _sprite[sprite].active = FALSE;
  164.       free(_sprite[sprite].mask);
  165.       selectplane(0x0f);
  166.       selectmask(0);
  167.       scrptr -= _sprite[sprite].fullsize;
  168.       for (scr1 = (scr2 = _sprite[sprite].data) + _sprite[sprite].fullsize;
  169.        scr1 < MK_FP(base, 0xffff); scr1++, scr2++) {
  170.      *scr2 = *scr1;
  171.       }
  172.       selectmask(0x0f);
  173.       for (i = 0; i < MAXSPRITES; i++) {
  174.      if (_sprite[i].active)
  175.         if (_sprite[i].data > _sprite[sprite].data)
  176.            _sprite[i].data -= _sprite[sprite].fullsize;
  177.       }
  178.  
  179.    }
  180.  
  181. }
  182.  
  183.  
  184. void killallsprites(void)
  185. {
  186.    int   i;
  187.  
  188.  
  189.    for (i = 0; i < MAXSPRITES; i++) {
  190.       if (_sprite[i].active) {
  191.      free(_sprite[i].mask);
  192.      _sprite[i].active = FALSE;
  193.       }
  194.    }
  195.  
  196.    scrptr = MK_FP(base, OFFSCREEN);
  197.  
  198. }
  199.  
  200.  
  201. void setpage(int p)
  202. {
  203.    page = p * PAGESIZE;
  204. }
  205.  
  206.  
  207. void initxmode(void)
  208. {
  209.    int   i;
  210.  
  211.    setxmode();
  212.    setstandardpalette();
  213.    windowx0 = XMIN; windowy0 = YMIN;
  214.    windowx1 = XMAX; windowy1 = YMAX;
  215.    for (i = 0; i < MAXSPRITES; i++) {
  216.       _sprite[i].active = FALSE;
  217.    }
  218.    scrptr = MK_FP(base, OFFSCREEN);
  219.    killstarfield();
  220.    killallobjects();
  221. }
  222.  
  223. void shutxmode(void)
  224. {
  225.  
  226.    killallobjects();
  227.    killallsprites();
  228.    killstarfield();
  229.    screenmode(2);
  230.  
  231. }
  232.  
  233. // #pragma startup initxmode
  234. // #pragma exit shutxmode
  235.  
  236.  
  237. // VGA color and palette functions.
  238.  
  239. static char standardpal[PALETTESIZE] = {
  240.    0x00,0x00,0x00,0x00,0x00,0x2A,0x00,0x2A,0x00,0x00,0x2A,0x2A,0x2A,0x00,0x00,0x2A,0x00,0x2A,0x2A,0x15,
  241.    0x00,0x2A,0x2A,0x2A,0x15,0x15,0x15,0x15,0x15,0x3F,0x15,0x3F,0x15,0x15,0x3F,0x3F,0x3F,0x15,0x15,0x3F,
  242.    0x15,0x3F,0x3F,0x3F,0x15,0x3F,0x3F,0x3F,0x3B,0x3B,0x3B,0x37,0x37,0x37,0x34,0x34,0x34,0x30,0x30,0x30,
  243.    0x2D,0x2D,0x2D,0x2A,0x2A,0x2A,0x26,0x26,0x26,0x23,0x23,0x23,0x1F,0x1F,0x1F,0x1C,0x1C,0x1C,0x19,0x19,
  244.    0x19,0x15,0x15,0x15,0x12,0x12,0x12,0x0E,0x0E,0x0E,0x0B,0x0B,0x0B,0x08,0x08,0x08,0x3F,0x00,0x00,0x3B,
  245.    0x00,0x00,0x38,0x00,0x00,0x35,0x00,0x00,0x32,0x00,0x00,0x2F,0x00,0x00,0x2C,0x00,0x00,0x29,0x00,0x00,
  246.    0x26,0x00,0x00,0x22,0x00,0x00,0x1F,0x00,0x00,0x1C,0x00,0x00,0x19,0x00,0x00,0x16,0x00,0x00,0x13,0x00,
  247.    0x00,0x10,0x00,0x00,0x3F,0x36,0x36,0x3F,0x2E,0x2E,0x3F,0x27,0x27,0x3F,0x1F,0x1F,0x3F,0x17,0x17,0x3F,
  248.    0x10,0x10,0x3F,0x08,0x08,0x3F,0x00,0x00,0x3F,0x2A,0x17,0x3F,0x26,0x10,0x3F,0x22,0x08,0x3F,0x1E,0x00,
  249.    0x39,0x1B,0x00,0x33,0x18,0x00,0x2D,0x15,0x00,0x27,0x13,0x00,0x3F,0x3F,0x36,0x3F,0x3F,0x2E,0x3F,0x3F,
  250.    0x27,0x3F,0x3F,0x1F,0x3F,0x3E,0x17,0x3F,0x3D,0x10,0x3F,0x3D,0x08,0x3F,0x3D,0x00,0x39,0x36,0x00,0x33,
  251.    0x31,0x00,0x2D,0x2B,0x00,0x27,0x27,0x00,0x21,0x21,0x00,0x1C,0x1B,0x00,0x16,0x15,0x00,0x10,0x10,0x00,
  252.    0x34,0x3F,0x17,0x31,0x3F,0x10,0x2D,0x3F,0x08,0x28,0x3F,0x00,0x24,0x39,0x00,0x20,0x33,0x00,0x1D,0x2D,
  253.    0x00,0x18,0x27,0x00,0x36,0x3F,0x36,0x2F,0x3F,0x2E,0x27,0x3F,0x27,0x20,0x3F,0x1F,0x18,0x3F,0x17,0x10,
  254.    0x3F,0x10,0x08,0x3F,0x08,0x00,0x3F,0x00,0x00,0x3F,0x00,0x00,0x3B,0x00,0x00,0x38,0x00,0x00,0x35,0x00,
  255.    0x01,0x32,0x00,0x01,0x2F,0x00,0x01,0x2C,0x00,0x01,0x29,0x00,0x01,0x26,0x00,0x01,0x22,0x00,0x01,0x1F,
  256.    0x00,0x01,0x1C,0x00,0x01,0x19,0x00,0x01,0x16,0x00,0x01,0x13,0x00,0x01,0x10,0x00,0x36,0x3F,0x3F,0x2E,
  257.    0x3F,0x3F,0x27,0x3F,0x3F,0x1F,0x3F,0x3E,0x17,0x3F,0x3F,0x10,0x3F,0x3F,0x08,0x3F,0x3F,0x00,0x3F,0x3F,
  258.    0x00,0x39,0x39,0x00,0x33,0x33,0x00,0x2D,0x2D,0x00,0x27,0x27,0x00,0x21,0x21,0x00,0x1C,0x1C,0x00,0x16,
  259.    0x16,0x00,0x10,0x10,0x17,0x2F,0x3F,0x10,0x2C,0x3F,0x08,0x2A,0x3F,0x00,0x27,0x3F,0x00,0x23,0x39,0x00,
  260.    0x1F,0x33,0x00,0x1B,0x2D,0x00,0x17,0x27,0x36,0x36,0x3F,0x2E,0x2F,0x3F,0x27,0x27,0x3F,0x1F,0x20,0x3F,
  261.    0x17,0x18,0x3F,0x10,0x10,0x3F,0x08,0x09,0x3F,0x00,0x01,0x3F,0x00,0x00,0x3F,0x00,0x00,0x3B,0x00,0x00,
  262.    0x38,0x00,0x00,0x35,0x00,0x00,0x32,0x00,0x00,0x2F,0x00,0x00,0x2C,0x00,0x00,0x29,0x00,0x00,0x26,0x00,
  263.    0x00,0x22,0x00,0x00,0x1F,0x00,0x00,0x1C,0x00,0x00,0x19,0x00,0x00,0x16,0x00,0x00,0x13,0x00,0x00,0x10,
  264.    0x3C,0x36,0x3F,0x39,0x2E,0x3F,0x36,0x27,0x3F,0x34,0x1F,0x3F,0x32,0x17,0x3F,0x2F,0x10,0x3F,0x2D,0x08,
  265.    0x3F,0x2A,0x00,0x3F,0x26,0x00,0x39,0x20,0x00,0x33,0x1D,0x00,0x2D,0x18,0x00,0x27,0x14,0x00,0x21,0x11,
  266.    0x00,0x1C,0x0D,0x00,0x16,0x0A,0x00,0x10,0x3F,0x36,0x3F,0x3F,0x2E,0x3F,0x3F,0x27,0x3F,0x3F,0x1F,0x3F,
  267.    0x3F,0x17,0x3F,0x3F,0x10,0x3F,0x3F,0x08,0x3F,0x3F,0x00,0x3F,0x38,0x00,0x39,0x32,0x00,0x33,0x2D,0x00,
  268.    0x2D,0x27,0x00,0x27,0x21,0x00,0x21,0x1B,0x00,0x1C,0x16,0x00,0x16,0x10,0x00,0x10,0x3F,0x3A,0x37,0x3F,
  269.    0x38,0x34,0x3F,0x36,0x31,0x3F,0x35,0x2F,0x3F,0x33,0x2C,0x3F,0x31,0x29,0x3F,0x2F,0x27,0x3F,0x2E,0x24,
  270.    0x3F,0x2C,0x20,0x3F,0x29,0x1C,0x3F,0x27,0x18,0x3C,0x25,0x17,0x3A,0x23,0x16,0x37,0x22,0x15,0x34,0x20,
  271.    0x14,0x32,0x1F,0x13,0x2F,0x1E,0x12,0x2D,0x1C,0x11,0x2A,0x1A,0x10,0x28,0x19,0x0F,0x27,0x18,0x0E,0x24,
  272.    0x17,0x0D,0x22,0x16,0x0C,0x20,0x14,0x0B,0x1D,0x13,0x0A,0x1B,0x12,0x09,0x17,0x10,0x08,0x15,0x0F,0x07,
  273.    0x12,0x0E,0x06,0x10,0x0C,0x06,0x0E,0x0B,0x05,0x0A,0x08,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  274.    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x31,0x0A,0x0A,0x31,
  275.    0x13,0x0A,0x31,0x1D,0x0A,0x31,0x27,0x0A,0x31,0x31,0x0A,0x27,0x31,0x0A,0x1D,0x31,0x0A,0x13,0x31,0x0A,
  276.    0x0A,0x31,0x0C,0x0A,0x31,0x17,0x0A,0x31,0x22,0x0A,0x31,0x2D,0x0A,0x2A,0x31,0x0A,0x1F,0x31,0x0A,0x14,
  277.    0x31,0x0B,0x0A,0x31,0x16,0x0A,0x31,0x21,0x0A,0x31,0x2C,0x0A,0x31,0x31,0x0A,0x2B,0x31,0x0A,0x20,0x31,
  278.    0x0A,0x15,0x31,0x0A,0x0A,0x3F,0x3F,0x3F
  279. };
  280.  
  281.  
  282.  
  283. void setpalette(char *ptr, int ncolors)
  284. {
  285.    struct REGPACK regs;
  286.  
  287.    regs.r_ax = 0x1012;
  288.    regs.r_bx = 0;
  289.    regs.r_cx = ncolors;
  290.    regs.r_dx = (unsigned) ptr;
  291.    regs.r_es = FP_SEG(ptr);
  292.    intr(0x10, ®s);
  293.  
  294. }
  295.  
  296.  
  297. void setcolor(int c, int r, int g, int b)
  298. {
  299.    outportb(0x3c8, c);
  300.    outportb(0x3c9, r);
  301.    outportb(0x3c9, g);
  302.    outportb(0x3c9, b);
  303. }
  304.  
  305. void setstandardpalette(void)
  306. {
  307.    memcpy(palette, standardpal, PALETTESIZE);
  308.    setpalette(palette, PALETTESIZE/3);
  309. }
  310.  
  311. void setvanillapalette(int c)
  312. {
  313.    int  i;
  314.  
  315.    for (i = 0; i < 256; i++)
  316.       setcolor(i, c, c, c);
  317.  
  318. }
  319.  
  320.  
  321. int cyclepalette(int c1, int c2, int pos)
  322. {
  323.    int   i;
  324.    int   n;
  325.  
  326.    if ((n = --pos + c1) < c1) pos = c2 - c1;
  327.    for (i = c2; i >= c1; i--) {
  328.       if (n < c1) n = c2;
  329.       setcolor(i, palette[n*3], palette[n*3+1], palette[n*3+2]);
  330.       n--;
  331.    }
  332.  
  333.    return pos;
  334. }
  335.  
  336.  
  337. void glowto(int r0, int g0, int b0)
  338. {
  339.    int  i, j;
  340.    int  r, g, b;
  341.  
  342.    for (i = 0; i < 63; i+=3) {
  343.       for (j = 0; j < 256; j++) {
  344.      r = (r0*i) / 63;
  345.      g = (g0*i) / 63;
  346.      b = (b0*i) / 63;
  347.      setcolor(j, r, g, b);
  348.       }
  349.       retrace();
  350.    }
  351. }
  352.  
  353.  
  354. void setattrib(int m)
  355. {
  356.    struct REGPACK regs;
  357.  
  358.    regs.r_ax = 0x1013;
  359.    regs.r_bx = (m << 8);
  360.    intr(0x10, ®s);
  361.  
  362. }
  363.  
  364.  
  365. void clearscreen(void)
  366. {
  367.  
  368.    selectplane(0x0f);
  369.    selectmask(0xff);
  370.    _fmemset(MK_FP(base, 0), backgrndcolor, PAGESIZE * 2);
  371.  
  372. }
  373.  
  374. void clearregion(int y, int n)
  375. {
  376.  
  377.    selectplane(0x0f);
  378.    selectmask(0xff);
  379.    _fmemset(MK_FP(base, y * BYTESPERLINE), backgrndcolor, n * BYTESPERLINE);
  380.    _fmemset(MK_FP(base, PAGESIZE + y * BYTESPERLINE), backgrndcolor, n * BYTESPERLINE);
  381.  
  382. }
  383.  
  384.  
  385. void showpcx256(void *pic, int line)
  386. {
  387.    int      height;
  388.    char     data, count;
  389.    unsigned i, size;
  390.    char     *pos;
  391.    char     far *scrptr;
  392.    int      plane;
  393.  
  394.  
  395.    height = ((int *)pic)[5] + 1;    // Get picture height.
  396.    pos = ((char *)pic)+128;        // Skip Header.
  397.  
  398.    scrptr = MK_FP(base, page + line*BYTESPERLINE);
  399.    plane = 1;
  400. // Decode picture.
  401.    while (FP_OFF(scrptr) < page + (height+line)*BYTESPERLINE) {
  402.       count = *pos; pos++;
  403.       if ((count & 0xc0) == 0xc0) {
  404.      count = count & 0x3f;
  405.      data = *pos; pos++;
  406.       } else {
  407.      data = count; count = 1;
  408.       }
  409.  
  410.       for (i = 0; i < count; i++) {
  411.      selectplane(plane);
  412.      *scrptr = data;
  413.      if ((plane <<= 1) > 8) {
  414.         plane = 1;
  415.         scrptr++;
  416.      }
  417.       }
  418.    }
  419. // Load palette.
  420.    pos++;
  421.    for (i = 0; i < PALETTESIZE; i++, pos++) {
  422.       palette[i] = (unsigned char)(*pos) >> 2;
  423.    }
  424.  
  425.  
  426. }
  427.  
  428.  
  429.